Technotools/Technotools (Chestnut CD-ROM)(1993).ISO/lantools/an103x/grace.c

C/C++ Source or Header | 1991-04-08 | 5KB | 264 lines

/*****************************************************************************
* GRACE.C
*
* 91-02-16 Matt Hagen, Novell, Inc.
*****************************************************************************/

#include <nwtypes.h>
#include <nwsemaph.h>
#include <nwipxspx.h>
#include <conio.h>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>

typedef struct WorkerStructure
{
    struct WorkerStructure *sLink;
    int threadID;
}WORKER;

void SignalRoutine(
    void);

void WorkerRoutine(
    void);

void UpdateRoutine(
    void);

#define CONTINUE 0
#define WAIT 1
#define EXIT 2

LONG semaphore;
BYTE threadCount=0;
WORKER *sList=NULL;
int updateThread;
BYTE globalExitFlag=CONTINUE;
BYTE threadInitFlag;

/*****************************************************************************
* main
*****************************************************************************/

main(
    int argc,
    char *argv[])
{
    int a;
    WORKER *w;

    signal(SIGTERM,SignalRoutine);
    threadCount++;

    semaphore=OpenLocalSemaphore(0);
    if(semaphore==NULL)
    {
        ConsolePrintf("  Cannot allocate semaphore.\n");
        globalExitFlag=EXIT;
        goto exit0;
    }

    for(a=0;a<5;a++)
    {
        threadInitFlag=WAIT;
        if(BeginThreadGroup(WorkerRoutine,NULL,NULL,NULL)==EFAILURE)
        {
            ConsolePrintf("  Cannot create session thread #%d.\n",a+1);
            globalExitFlag=EXIT;
            goto exit1;
        }

        while(threadInitFlag==WAIT)
            ThreadSwitch();

        if(threadInitFlag!=CONTINUE)
        {
            globalExitFlag=EXIT;
            goto exit1;
        }
    }

    threadInitFlag=WAIT;
    if(BeginThreadGroup(UpdateRoutine,NULL,NULL,NULL)==EFAILURE)
    {
        ConsolePrintf("  Cannot create screen thread.\n");
        globalExitFlag=EXIT;
        goto exit1;
    }

    while(threadInitFlag==WAIT)
        ThreadSwitch();

    if(threadInitFlag!=CONTINUE)
    {
        globalExitFlag=EXIT;
        goto exit1;
    }

    while(TRUE)
    {
        WaitOnLocalSemaphore(semaphore);
        if(globalExitFlag!=CONTINUE)
            goto exit2;

        /* take worker off sleep list */
        /* give request to worker */
        /* wake up worker */
    }

exit2:;
    ResumeThread(updateThread);

exit1:;
    w=sList;
    while(w!=NULL)
    {
        ResumeThread(w->threadID);
        w=w->sLink;
    }

    while(threadCount>1)
        ThreadSwitch();

exit0:;
    CloseLocalSemaphore(semaphore);

    threadCount--;
}

/*****************************************************************************
* SignalRoutine
*****************************************************************************/

void SignalRoutine(
    void)
{
    globalExitFlag=EXIT;

    SignalLocalSemaphore(semaphore);

    while(threadCount>0)
        ThreadSwitch();
}

/*****************************************************************************
* WorkerRoutine
*****************************************************************************/

void WorkerRoutine(
    void)
{
    WORKER *w;
    void *ecb;

    signal(SIGTERM,SignalRoutine);
    threadCount++;

    w=malloc(sizeof(WORKER));
    if(w==NULL)
    {
        ConsolePrintf("  Cannot allocate WORKER structure.\n");
        threadInitFlag=EXIT;
        goto exit0;
    }

    ecb=malloc(sizeof(IPX_ECB));
    if(ecb==NULL)
    {
        ConsolePrintf("  Cannot allocate session memory.\n");
        threadInitFlag=EXIT;
        goto exit1;
    }

    w->threadID=GetThreadID();
    threadInitFlag=CONTINUE;

    while(TRUE)
    {
        w->sLink=sList;
        sList=w;
        SuspendThread(w->threadID);

        if(globalExitFlag!=CONTINUE)
            goto exit2;

        /* service the request */
    }

exit2:;
    free(ecb);

exit1:;
    free(w);

exit0:;
    threadCount--;
    SuspendThread(GetThreadID());
}

/*****************************************************************************
* UpdateRoutine
*****************************************************************************/

void UpdateRoutine(
    void)
{
    int screen;
    LONG count=0;

    signal(SIGTERM,SignalRoutine);
    threadCount++;

    updateThread=GetThreadID();

    screen=CreateScreen("Graceful Screen",AUTO_DESTROY_SCREEN);
    if(screen==EFAILURE)
    {
        ConsolePrintf("  Cannot create screen.\n");
        threadInitFlag=EXIT;
        goto exit0;
    }

    HideInputCursor();

    if(DisplayScreen(screen)!=ESUCCESS)
    {
        ConsolePrintf("  Cannot display screen.\n");
        threadInitFlag=EXIT;
        goto exit1;
    }

    threadInitFlag=CONTINUE;

    gotoxy(20,0);
    printf("Graceful Init/Deinit Example Screen");

    while(TRUE)
    {
        SetCurrentScreen(screen);

        gotoxy(0,2);
        printf("Update Count = %u\n",count++);
        printf("Thread Count = %u",threadCount);
        delay(1000);

        if(globalExitFlag!=CONTINUE)
            goto exit1;
    }

exit1:;
    DestroyScreen(screen);

exit0:;
    threadCount--;

    SuspendThread(updateThread);
}

/****************************************************************************/
/****************************************************************************/